Dependencies¶

Opps makes use of as few libraries as possible (apart from a standard Django environment), with the following dependencies

• Python 2.7
• Django >= 1.5
• Python Imaging Library - for image resizing
• South - for database migrations
• Django Taggit
• Django Mptt

Features¶

• Write in Django
• Containar manager (container is content type in Opps CMS)
• • Save draft and and preview
• • Dynamic custom field, add field in specific container
• WYSIWYG editing (more one option)
• Container Box manager (Custom channel home page, add dynamic/fix box)
• Channel organize via tree (via mptt, not level limit)
• Media file manager, default manager images
• • Multi upload
• User permission in Admin, manager site access on admin
• Configurable dashboard (used grappelli admin theme)
• API for custom container types
• Search engine
• Multi-Site
• SEO friendly URLs and meta data
• Mobile detect
• JVM compatible (via Jython)
• .NET Framework compatible (via IronPython)

Browser Support¶

Opps’s admin (used Django Grappelli) interface works with all modern browsers.

Language Translations¶

Opps makes full use of translation strings, which allow Opps to be translated into multiple languages using Django’s internationalization methodology. Translations are managed on the Transiflex website but can also be submitted via GitHub. Consult the documentation for Django’s internationalization methodology for more information on creating translations and using them.

Sites Using Opps¶

• Portal Virgula
• Portal Guiame
• Grupo Troiano
• Troiano
• Brands and Values
• Brigh Thouse
• Brand Insights
• JovemPan AM
• JovemPan FM

Getting help¶

Should you run into trouble and can’t figure out how to solve it yourself, you can get help from either our mailinglist or IRC channel #opps on the irc.freenode.net network.

Start¶

git clone https://github.com/opps/opps.git
cd opps
python setup.py develop
opps-admin.py startproject PROJECT_NAME
cd PROJECT_NAME
python manage.py syncdb --noinput
python manage.py migrate
python manage.py collectstatic --noinput
python manage.py runserver

Installation¶

You can use pip to install Opps and requirements

pip install opps

or

git clone git@github.com:opps/opps.git
cd opps
python setup.py install

Start project¶

You can use opps-admin.py to start new project

opps-admin.py startproject PROJECT_NAME

Usage¶

command should be one of the commands listed in this document. options, which is optional, should be zero or more of the options available for the given command.

opps-admin.py <command> [options]

Opps default¶

• Channel: templates/containers/list.html
• Content: templates/containers/detail.html

Details¶

• containers/<channel-slug>/<sub-channel-slug>/<container-slug>/detail.html
• containers/<channel-slug>/<sub-channel-slug>/<container-child-class>_detail.html
• containers/<channel-slug>/<sub-channel-slug>/detail.html
• containers/<channel-slug>/<container-child-class>_detail.html
• containers/<channel>/detail.html
• containers/detail.html

Channel conf¶

All channel configuration is one json file, a channel can have more than one layout, changed when editing channel (file name templates/containers/<channel-name>/channel.json):

{"layout": ["home_1", "home_2"]}

The Container Model¶

The conventions of a Opps site is the modelo opps.containers.models.Container. Each container instance is stored in a hierarchical tree to form the content navigation, and an interface for managing the structure of the navigation tree is provided in the admin via opps.containers.admin.ContainerAdmin.

Creating Custom Content Type¶

In order to handle different content type that require more structured content than provided by the Post, Album or Link model, you can simply create your own models that inherit from Container. For example if we wanted to have content that were music, author and studio:

# -*- coding: utf-8 -*-
from django.db import models
from opps.containers.models import Container


class Musics(Container):
    music = models.CharField(_(u"Music"), max_length=140)
    author = models.CharField(_(u"Author"), max_length=140)
    studio = models.CharField(_(u"Studio"), max_length=200)

    class META:
        verbose_name = _('Music')
        verbose_name_plural = _('Musics')

Next you’ll need to register your model with Django’s admin to make it available as a content type. If your content type only exposes some new fields that you’d like to make editable in the admin, you can simply register your model using the opps.containers.admin.ContainerAdmin class:

# -*- coding: utf-8 -*-
from django.contrib import admin
from opps.containers.admin import ContainerAdmin
from .models import Musics

admin.site.register(Musics, ContainerAdmin)

Get all containers object¶

• /api/v1/container/?format=json

Get container object¶

• /api/v1/<child class>/<id>/?format=json
• /api/v1/post/<id>/?format=json
• /api/v1/album/<id>/?format=json
• /api/v1/link/<id>/?format=json

Opps Editor¶

By default it uses Tinymce

OPPS_EDITOR = {
    'editor': 'aloha',
    'js': ("//cdn.aloha-editor.org/latest/lib/require.js",),
    "css": ("//cdn.aloha-editor.org/latest/css/aloha.css",)
}

pip install django-wysiwyg-redactor

urlpatterns = patterns(
    '',
    url(r'^media/(?P<path>.*)$', 'django.views.static.serve',
    {'document_root': settings.MEDIA_ROOT, 'show_indexes': True}),
    url(r'^', include('opps.urls')),
    # django redactor
    url(r'^redactor/', include('redactor.urls')),
)

OPPS_EDITOR = {
    'editor': 'redactor',
    'js': ('redactor/redactor.min.js',),
    "css": ('redactor/css/redactor.css',
            'redactor/css/django_admin.css')
}

opps.api¶

opps.archives¶

opps.articles¶

opps.boxes¶

opps.channels¶

opps.containers¶

opps.contrib.feeds¶

opps.contrib.fileupload¶

opps.contrib.logging¶

Application to generate log project actions

$.ajax({
    type: 'POST',
    url: '/api/v1/contrib/logging/',
    data: '{"application": "player", "action": "play"}',
    dataType: "application/json",
    processData:  false,
    contentType: "application/json"
});

opps.contrib.mobile¶

opps.contrib.multisite¶

opps.contrib.notifications¶

opps.core.tags¶

opps.core.templatetags¶

opps.db._redis¶

opps.db.backends.postgresql_psycopg2¶

opps.fields¶

opps.flatpages¶

opps.images¶

opps.search¶

opps.sitemaps¶

opps.views¶

Forking Opps¶

Assuming you have already set up Git, the first step is to navigate to the Opps project page and select the Fork button at top-right.

Next, clone your fork (replace GH-USER with your GitHub username):

git clone https://github.com/GH-USER/opps.git

This adds a “remote” for your fork called “origin”. Add the canonical Opps project as an additional remote called “upstream”:

cd opps
git remote add upstream https://github.com/opps/opps.git

Making your changes¶

Create and switch to a new branch to house your feature or bugfix (replace newfeaturebranch with an appropriate name):

git fetch upstream
git checkout -b newfeaturebranch upstream/master

Once you are satisfied with your changes, run the tests and check coding standards:

make test

Once the tests all pass and you are comfortable that your code complies with the suggested coding standards, add and commit your changes:

git add changedfile1 changedfile2
git commit

Push your new branch, and the commit(s) within, to your fork:

git push origin newfeaturebranch

Issuing a pull request¶

Read the GitHub pull request documentation first. Then navigate to your Opps fork at https://github.com/GH-USER/opps, select the new branch from the drop-down, and select “Pull Request”. Enter a title and description for your pull request, review the proposed changes using the “Commits” and “Files Changed” tabs, and select “Send pull request”.

If someone reviews your contribution and ask you to make more changes, do so and then rebase to upstream master:

git checkout newfeaturebranch
git fetch upstream
git rebase -p upstream/master

When prompted, include a relevant commit message, describing all your changes. Finally, push your changes via:

git push --force origin newfeaturebranch

Squashing commits¶

If you are asked to squash your commits:

git checkout newfeaturebranch
git fetch upstream
git rebase upstream/master
git rebase -i

When prompted, mark your initial commit with pick, and all your follow-on commits with squash.

Then edit the commit message to make sense, taking out any extraneous information and succinctly describing your changes. Finally, push your changes via:

git push --force origin newfeaturebranch

Relevant Resources¶

• Git merge vs. rebase

South Migrations¶

For every migration created, make the following modifications.

from django.contrib.auth import get_user_model
User = get_user_model()


class Migration(SchemaMigration):

    def forwards(self, orm):
        # reapeat the following for every create or alter table using "user" relation
        db.create_table('app.model', (
            ('user', self.gf('django...ForeignKey')(to=orm["%s.%s" % (User._meta.app_label, User._meta.object_name)])

    models = {
        ...
        # this should replace "auth.user or accounts.customuser"
        "%s.%s" % (User._meta.app_label, User._meta.module_name): {
            'Meta': {'object_name': User.__name__},
        }

        # repeat the following for every freezed model
        "app.model": {
            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['%s.%s']"% (User._meta.app_label, User._meta.object_name)})
        }
    }

Haystack¶

The default haystack search template is the same you find in haystack home page, the difference in opps is that for every indexed Model you should implement some fields, properties or methods.

Required for search

• title (The title used on search result)
• search_category (It can be used to group things on tabs or just to show the category)
• get_absolute_url (The url for search result)
• get_thumb (optional image path for search result)

Example

class MyModel(models.Model):
    title = models.CharField(max_length=255) # implemented as field
    slug = models.SlugField()
    image = models.FileField()

    # implemented as method
    def get_absolute_url(self):
        return "posts/{0}".format(self.slug)

    # implemented as method
    def get_thumb(self):
        return get_thumb_url_or_something(self.image)

    # implemented as property
    @property
    def search_category(self):
        return _(' Blog post')

With the above in your model, you can now create your search_indexes and template and choose to index those fields/properties/methods or just access directly on template. (see haystack docs)

Example of search template

{% load images_tags %}


<h2>Search</h2>

<form method="get" action=".">
    <table>
        <input type="search" id="q" name="q" placeholder="Search" value="{{ request.GET.q}}" required>
        <tr>
            <td>&nbsp;</td>
            <td>
                <input type="submit" value="Search">
            </td>
        </tr>
    </table>

    {% if query %}
        <h3>Results</h3>

        {% for result in page.object_list %}
            <p>
              <small>{{ result.object.search_category }}</small><br>
              {% if result.object.get_thumb %}
              <a href="{{ result.object.get_absolute_url }}">
                  <img src="{% image_url result.object.get_thumb.archive.url width=100 height=100 %}" alt="{{ result.object.title}}" class="span2" />
              </a>
              {% endif %}

                <a href="{{ result.object.get_absolute_url }}">{{ result.object.title }}</a>
            </p>
        {% empty %}
            <p>No results found.</p>
        {% endfor %}

        {% if page.has_previous or page.has_next %}
            <div>
                {% if page.has_previous %}<a href="?q={{ query }}&amp;page={{ page.previous_page_number }}">{% endif %}&laquo; Previous{% if page.has_previous %}</a>{% endif %}
                |
                {% if page.has_next %}<a href="?q={{ query }}&amp;page={{ page.next_page_number }}">{% endif %}Next &raquo;{% if page.has_next %}</a>{% endif %}
            </div>
        {% endif %}
    {% else %}
        {# Show some example queries to run, maybe query syntax, something else? #}
    {% endif %}
</form>

Developing¶

We strive to keep the internal quality of opps to the best that we can; Therefore, it’s very important to keep some things in mind when contributing with code for opps:

• Test everything you can, with automated tests. If possible, please develop code with TDD. If you’re having a hard time building tests, don’t hesitate to ask for help in the opps mailing list. We are happy to help you keep your code well-covered by tests;
• When writing actual code, follow the conventions in PEP 8 (except for maximum line length, which we don’t follow because there are too many parts of the project that require large strings to be used);
• When writing docstrings, follow the conventions in PEP 257 (take a look at other docstrings in the project to get a feel of how we organize them);
  • Also, when writing docstrings for the API, provide examples of how that method or class works. Having a code example of a part of the API is really helpful for the user.

Developer Setup¶

Software required in OS:

• Redis Server
• SQLite
• Image Lib

Check out the code from the github project:

git clone git://github.com/opps/opps.git
cd opps

Create a virtualenv (the example here is with virtualenvwrapper) and install all development packages:

mkvirtualenv opps
pip install -r requirements_dev.txt
python setup.py develop

Here is how to run the test suite:

make test

Here is how to build the documentation:

cd docs
make html

Architecture¶

The team¶